var express = require('express');
var router = express.Router();
var zjxModel = require('../db/zjx');
const mongoose = require('../db/setmongoose');
const { client, FACE_LIBRARY_CONFIG, FACE_RECOGNITION_CONFIG, isConfigValid } = require('../config/tencent');

// 中间件：检查腾讯云配置是否有效
const checkTencentConfig = (req, res, next) => {
  try {
    if (!isConfigValid()) {
      return res.status(500).json({
        success: false,
        message: '腾讯云人脸识别服务未正确配置，请检查环境变量',
        error: 'Missing TENCENTCLOUD_SECRET_ID or TENCENTCLOUD_SECRET_KEY'
      });
    }
    next();
  } catch (error) {
    console.error('配置检查失败:', error);
    return res.status(500).json({
      success: false,
      message: '腾讯云配置检查失败',
      error: error.message
    });
  }
};

/* GET users listing. */
router.get('/', function(req, res, next) {
  res.send('respond with a resource');
});

/* POST 用户注册 */
router.post('/register', async function(req, res, next) {
  try {
    const { phone, password, name } = req.body;
    
    // 验证必填字段
    if (!phone || !password) {
      return res.status(400).json({
        success: false,
        message: '手机号和密码不能为空'
      });
    }
    
    // 检查数据库连接状态
    if (mongoose.connection.readyState !== 1) {
      return res.status(503).json({
        success: false,
        message: '数据库连接异常，请稍后重试',
        error: 'Database connection error'
      });
    }
    
    // 检查手机号是否已存在
    const existingUser = await zjxModel.findOne({ phone: phone });
    let savedUser;
    
    if (existingUser) {
      // 如果用户已存在，更新用户信息
      existingUser.name = name || existingUser.name;
      existingUser.password = password;
      existingUser.updatedAt = new Date();
      savedUser = await existingUser.save();
      
      res.status(200).json({
        success: true,
        message: '用户信息更新成功',
        data: {
          id: savedUser._id,
          phone: savedUser.phone,
          name: savedUser.name
        }
      });
    } else {
      // 创建新用户
      const newUser = new zjxModel({
        name: name || '',
        phone: phone,
        password: password,
        createdAt: new Date(),
        updatedAt: new Date()
      });
      
      // 保存到数据库
      savedUser = await newUser.save();
      
      res.status(201).json({
        success: true,
        message: '注册成功',
        data: {
          id: savedUser._id,
          phone: savedUser.phone,
          name: savedUser.name
        }
      });
    }
    
  } catch (error) {
    console.error('注册失败:', error);
    
    // 根据错误类型返回不同的错误信息
    let errorMessage = '服务器内部错误，注册失败';
    if (error.name === 'MongooseError' && error.message.includes('buffering timed out')) {
      errorMessage = '数据库连接超时，请稍后重试';
    } else if (error.name === 'MongoNetworkError') {
      errorMessage = '网络连接异常，请检查网络后重试';
    }
    
    res.status(500).json({
      success: false,
      message: errorMessage,
      error: error.message
    });
  }
});

/* POST 发送验证码 */
router.post('/sendVerificationCode', async function(req, res, next) {
  try {
    const { phone, type } = req.body;
    
    // 验证手机号
    if (!phone) {
      return res.status(400).json({
        success: false,
        message: '手机号不能为空'
      });
    }
    
    // 验证手机号格式
    const phoneReg = /^1[3-9]\d{9}$/;
    if (!phoneReg.test(phone)) {
      return res.status(400).json({
        success: false,
        message: '手机号格式不正确'
      });
    }
    
    // 简化逻辑：不强制检查手机号是否已注册，允许发送验证码
    // 这样可以避免已注册用户无法重新注册的问题
    
    // 生成6位随机验证码
    const verificationCode = Math.floor(100000 + Math.random() * 900000).toString();
    
    // 在实际生产环境中，这里应该调用短信服务发送验证码
    // 目前返回验证码用于测试
    res.status(200).json({
      success: true,
      message: '验证码发送成功',
      verificationCode: verificationCode // 仅用于测试，生产环境应移除
    });
    
  } catch (error) {
    console.error('发送验证码失败:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误，发送验证码失败'
    });
  }
});

// ==================== 人脸识别相关路由 ====================

// 人脸检测路由
router.post('/detect-face', checkTencentConfig, async (req, res) => {
  try {
    const { base64 } = req.body;
    
    if (!base64) {
      return res.status(400).json({
        success: false,
        message: '缺少图片数据'
      });
    }

    console.log('收到人脸检测请求，图片数据长度:', base64.length);

    // 检查base64数据是否有效
    if (base64.length < 100) {
      return res.status(400).json({
        success: false,
        message: '图片数据过短，可能不是有效的图片',
        dataLength: base64.length,
        suggestions: [
          '请确保图片包含清晰的人脸',
          '建议图片大小在100KB-1MB之间',
          '图片分辨率建议至少640x480像素'
        ]
      });
    }

    // 使用最兼容的人脸检测参数
    const params = {
      "Image": base64,
      "FaceModelVersion": "3.0"
      // 移除不支持的参数：MaxFaceNum, NeedFaceDetection, NeedRotateDetection, NeedFaceAttributes
    };

    console.log('调用腾讯云人脸检测API，参数:', {
      FaceModelVersion: params.FaceModelVersion
    });

    console.log('开始调用腾讯云API...');
    const result = await client.AnalyzeFace(params);
    
    console.log('人脸检测结果:', JSON.stringify(result, null, 2));
    
    // 检查API返回结果
    if (result && typeof result === 'object') {
      if (result.FaceNum !== undefined && result.FaceNum > 0) {
        res.json({
          success: true,
          data: result,
          message: `检测到 ${result.FaceNum} 个人脸`,
          faceCount: result.FaceNum
        });
      } else {
        res.json({
          success: false,
          message: '未检测到人脸，请确保：\n1. 图片中包含清晰的人脸\n2. 光线充足\n3. 人脸角度适中\n4. 图片质量良好',
          data: result,
          faceCount: 0,
          suggestions: [
            '尝试调整光线，确保人脸清晰可见',
            '确保人脸正面朝向摄像头',
            '避免戴墨镜、帽子等遮挡物',
            '距离摄像头30-50厘米'
          ]
        });
      }
    } else {
      res.json({
        success: false,
        message: 'API返回结果格式异常',
        data: result,
        faceCount: 0
      });
    }

  } catch (error) {
    console.error('人脸检测失败:', error);
    
    // 提供更详细的错误信息
    let errorMessage = '人脸检测失败';
    if (error.code) {
      errorMessage += ` (错误代码: ${error.code})`;
    }
    if (error.message) {
      errorMessage += `: ${error.message}`;
    }
    
    // 根据错误类型提供建议
    let suggestions = [];
    if (error.code === 'InvalidParameter') {
      suggestions.push('图片格式可能不正确，请确保是有效的JPEG/PNG图片');
      suggestions.push('检查图片数据是否完整');
    } else if (error.code === 'AuthFailure') {
      suggestions.push('腾讯云认证失败，请检查API密钥配置');
      suggestions.push('联系管理员检查服务配置');
    } else if (error.code === 'RequestLimitExceeded') {
      suggestions.push('API调用频率超限，请稍后再试');
      suggestions.push('建议等待1-2分钟后重试');
    } else if (error.code === 'FailedOperation.ImageResolutionTooSmall') {
      suggestions.push('图片分辨率太小，建议使用至少640x480像素的图片');
      suggestions.push('请确保图片包含清晰的人脸，光线充足');
      suggestions.push('建议使用真实摄像头拍摄的图片进行测试');
    } else if (error.code === 'FailedOperation.ImageDecodeFailed') {
      suggestions.push('图片格式可能不正确，请确保是有效的JPEG/PNG图片');
      suggestions.push('检查图片数据是否完整');
      suggestions.push('建议使用真实摄像头拍摄的图片进行测试');
    } else {
      suggestions.push('请检查网络连接是否正常');
      suggestions.push('尝试重新拍照');
      suggestions.push('如果问题持续，请联系技术支持');
    }
    
    res.status(500).json({
      success: false,
      message: errorMessage,
      error: error.message,
      code: error.code || 'UNKNOWN_ERROR',
      suggestions: suggestions,
      debug: {
        imageLength: base64 ? base64.length : 0,
        timestamp: new Date().toISOString()
      }
    });
  }
});

// 人脸识别登录路由
router.post('/face-login', checkTencentConfig, async (req, res) => {
  try {
    const { base64, groupId } = req.body;
    
    if (!base64) {
      return res.status(400).json({
        success: false,
        message: '缺少图片数据'
      });
    }

    console.log('收到人脸识别登录请求，图片数据长度:', base64.length);
    const targetGroupId = groupId || FACE_LIBRARY_CONFIG.groupId;
    console.log('使用人脸库ID:', targetGroupId);

    // 1. 先进行人脸检测
    const detectParams = {
      "Image": base64,
      "FaceModelVersion": "3.0"
    };

    console.log('开始人脸检测...');
    const detectResult = await client.AnalyzeFace(detectParams);
    console.log('人脸检测结果:', JSON.stringify(detectResult, null, 2));
    
    if (!detectResult.FaceNum || detectResult.FaceNum === 0) {
      return res.status(400).json({
        success: false,
        message: '未检测到人脸，请重新拍照',
        suggestions: [
          '确保图片中包含清晰的人脸',
          '调整光线，确保人脸清晰可见',
          '确保人脸正面朝向摄像头',
          '避免戴墨镜、帽子等遮挡物',
          '距离摄像头30-50厘米'
        ]
      });
    }

    // 2. 在人脸库中搜索匹配的人脸
    const searchParams = {
      "Image": base64,
      "GroupIds": [targetGroupId],
      "MatchThreshold": FACE_RECOGNITION_CONFIG.similarityThreshold
    };

    console.log('开始人脸搜索，相似度阈值:', FACE_RECOGNITION_CONFIG.similarityThreshold);
    const searchResult = await client.SearchFaces(searchParams);
    console.log('人脸搜索结果:', JSON.stringify(searchResult, null, 2));
    
    if (searchResult.FaceMatches && searchResult.FaceMatches.length > 0) {
      const bestMatch = searchResult.FaceMatches[0];
      console.log('最佳匹配结果:', {
        PersonId: bestMatch.PersonId,
        PersonName: bestMatch.PersonName,
        Similarity: bestMatch.Similarity,
        Threshold: FACE_RECOGNITION_CONFIG.similarityThreshold
      });
      
      if (bestMatch.Similarity >= FACE_RECOGNITION_CONFIG.similarityThreshold) {
                 // 登录成功，查找对应的用户信息
         try {
           // 检查数据库连接状态
           if (mongoose.connection.readyState !== 1) {
             console.log('数据库未连接，跳过用户信息查询');
             res.json({
               success: true,
               message: '人脸识别登录成功',
               data: {
                 personId: bestMatch.PersonId,
                 personName: bestMatch.PersonName,
                 similarity: bestMatch.Similarity,
                 faceId: bestMatch.FaceId,
                 note: '数据库连接异常，无法获取用户详细信息'
               }
             });
             return;
           }
           
           const user = await zjxModel.findOne({ personId: bestMatch.PersonId });
           if (user) {
             console.log('找到用户信息:', user);
             res.json({
               success: true,
               message: '人脸识别登录成功',
               data: {
                 personId: bestMatch.PersonId,
                 personName: bestMatch.PersonName,
                 similarity: bestMatch.Similarity,
                 faceId: bestMatch.FaceId,
                 userInfo: {
                   id: user._id,
                   name: user.name,
                   phone: user.phone
                 }
               }
             });
           } else {
             console.log('未找到用户信息，PersonId:', bestMatch.PersonId);
             res.json({
               success: true,
               message: '人脸识别成功，但未找到用户信息',
               data: {
                 personId: bestMatch.PersonId,
                 personName: bestMatch.PersonName,
                 similarity: bestMatch.Similarity,
                 faceId: bestMatch.FaceId
               }
             });
           }
         } catch (dbError) {
           console.error('查询用户信息失败:', dbError);
           res.json({
             success: true,
             message: '人脸识别登录成功',
             data: {
               personId: bestMatch.PersonId,
               personName: bestMatch.PersonName,
               similarity: bestMatch.Similarity,
               faceId: bestMatch.FaceId,
               note: '用户信息查询失败，但人脸识别成功'
             }
           });
         }
      } else {
        console.log('相似度不足:', bestMatch.Similarity, '<', FACE_RECOGNITION_CONFIG.similarityThreshold);
        res.status(401).json({
          success: false,
          message: '人脸匹配度不足，登录失败',
          data: {
            similarity: bestMatch.Similarity,
            threshold: FACE_RECOGNITION_CONFIG.similarityThreshold
          },
          suggestions: [
            '请确保是注册时使用的同一张人脸',
            '调整光线和角度',
            '确保人脸清晰可见',
            '避免戴墨镜、帽子等遮挡物'
          ]
        });
      }
    } else {
      console.log('未找到匹配的人脸');
      res.status(401).json({
        success: false,
        message: '未找到匹配的人脸，请先注册',
        suggestions: [
          '请先使用人脸注册功能注册您的人脸',
          '确保使用相同的设备进行注册和识别',
          '检查人脸库中是否已有您的人脸数据'
        ]
      });
    }

  } catch (error) {
    console.error('人脸识别登录失败:', error);
    
    // 提供更详细的错误信息
    let errorMessage = '人脸识别登录失败';
    if (error.code) {
      errorMessage += ` (错误代码: ${error.code})`;
    }
    if (error.message) {
      errorMessage += `: ${error.message}`;
    }
    
    // 根据错误类型提供建议
    let suggestions = [];
    if (error.code === 'InvalidParameter') {
      suggestions.push('图片格式可能不正确，请确保是有效的JPEG/PNG图片');
      suggestions.push('检查图片数据是否完整');
    } else if (error.code === 'AuthFailure') {
      suggestions.push('腾讯云认证失败，请检查API密钥配置');
      suggestions.push('联系管理员检查服务配置');
    } else if (error.code === 'RequestLimitExceeded') {
      suggestions.push('API调用频率超限，请稍后再试');
      suggestions.push('建议等待1-2分钟后重试');
    } else if (error.code === 'ResourceNotFound') {
      suggestions.push('人脸库不存在，请联系管理员');
    } else {
      suggestions.push('请检查网络连接是否正常');
      suggestions.push('尝试重新拍照');
      suggestions.push('如果问题持续，请联系技术支持');
    }
    
    res.status(500).json({
      success: false,
      message: errorMessage,
      error: error.message,
      code: error.code || 'UNKNOWN_ERROR',
      suggestions: suggestions,
      debug: {
        imageLength: base64 ? base64.length : 0,
        groupId: targetGroupId,
        timestamp: new Date().toISOString()
      }
    });
  }
});

// 人脸注册路由
router.post('/face-register', checkTencentConfig, async (req, res) => {
  try {
    const { base64, personName, personId, groupId, phone, password } = req.body;
    
    if (!base64 || !personName || !personId) {
      return res.status(400).json({
        success: false,
        message: '缺少必要参数'
      });
    }

    console.log('收到人脸注册请求:', { personName, personId, imageLength: base64.length });

    const targetGroupId = groupId || FACE_LIBRARY_CONFIG.groupId;

    // 1. 先检测人脸质量和数量
    const detectParams = {
      "Image": base64,
      "FaceModelVersion": "3.0"
    };

    console.log('开始人脸检测...');
    const detectResult = await client.AnalyzeFace(detectParams);
    console.log('人脸检测结果:', JSON.stringify(detectResult, null, 2));
    
    if (!detectResult.FaceNum || detectResult.FaceNum === 0) {
      return res.status(400).json({
        success: false,
        message: '未检测到人脸，请确保：\n1. 图片中包含清晰的人脸\n2. 光线充足\n3. 人脸角度适中\n4. 图片质量良好',
        data: detectResult
      });
    }

    if (detectResult.FaceNum > 1) {
      return res.status(400).json({
        success: false,
        message: `检测到 ${detectResult.FaceNum} 个人脸，请只包含一个人脸进行注册`,
        data: detectResult
      });
    }

    // 检查人脸质量（简化检查）
    if (detectResult.FaceInfos && detectResult.FaceInfos.length > 0) {
      const faceInfo = detectResult.FaceInfos[0];
      // 检查人脸是否太小或位置不当
      if (faceInfo.FaceRect) {
        const { Width, Height } = faceInfo.FaceRect;
        if (Width < 50 || Height < 50) {
          return res.status(400).json({
            success: false,
            message: '人脸太小，请靠近摄像头重新拍照',
            data: detectResult
          });
        }
      }
    }

    // 2. 创建人脸
    console.log('开始创建人脸...');
    const createParams = {
      "GroupId": targetGroupId,
      "PersonName": personName,
      "PersonId": personId,
      "Image": base64,
      "PersonExDescription": `注册时间: ${new Date().toISOString()}`
    };

    const result = await client.CreateFace(createParams);
    console.log('人脸创建结果:', JSON.stringify(result, null, 2));
    
         // 3. 如果提供了手机号和密码，同时创建用户账户
     let userData = null;
     if (phone && password) {
       try {
         // 检查数据库连接状态
         if (mongoose.connection.readyState !== 1) {
           console.log('数据库未连接，跳过用户账户创建');
           res.json({
             success: true,
             message: '人脸注册成功，但用户账户创建失败（数据库连接异常）',
             data: {
               faceResult: result,
               note: '数据库连接异常，无法创建用户账户'
             }
           });
           return;
         }
         
         // 检查手机号是否已存在
         const existingUser = await zjxModel.findOne({ phone: phone });
         if (existingUser) {
           return res.status(409).json({
             success: false,
             message: '该手机号已被注册'
           });
         }
         
         // 创建新用户
         const newUser = new zjxModel({
           name: personName,
           phone: phone,
           password: password,
           personId: personId, // 关联人脸库中的personId
           createdAt: new Date(),
           updatedAt: new Date()
         });
         
         userData = await newUser.save();
         console.log('用户账户创建成功:', userData._id);
       } catch (dbError) {
         console.error('创建用户账户失败:', dbError);
         // 人脸注册成功，但用户账户创建失败
         res.json({
           success: true,
           message: '人脸注册成功，但用户账户创建失败',
           data: {
             faceResult: result,
             userError: dbError.message
           }
         });
         return;
       }
     }
    
    res.json({
      success: true,
      message: '人脸注册成功',
      data: {
        faceResult: result,
        userData: userData ? {
          id: userData._id,
          name: userData.name,
          phone: userData.phone,
          personId: userData.personId
        } : null
      }
    });

  } catch (error) {
    console.error('人脸注册失败:', error);
    
    let errorMessage = '人脸注册失败';
    if (error.code) {
      errorMessage += ` (错误代码: ${error.code})`;
    }
    if (error.message) {
      errorMessage += `: ${error.message}`;
    }
    
    res.status(500).json({
      success: false,
      message: errorMessage,
      error: error.message,
      code: error.code || 'UNKNOWN_ERROR'
    });
  }
});

// 健康检查路由
router.get('/face-health', (req, res) => {
  try {
    if (isConfigValid()) {
      res.json({
        success: true,
        message: '腾讯云人脸识别服务正常运行',
        timestamp: new Date().toISOString(),
        config: {
          region: 'ap-beijing',
          groupId: FACE_LIBRARY_CONFIG.groupId,
          groupName: FACE_LIBRARY_CONFIG.groupName,
          similarityThreshold: FACE_RECOGNITION_CONFIG.similarityThreshold,
          maxFaceNum: FACE_RECOGNITION_CONFIG.maxFaceNum,
          needQuality: FACE_RECOGNITION_CONFIG.needQuality,
          qualityThreshold: FACE_RECOGNITION_CONFIG.qualityThreshold
        }
      });
    } else {
      res.status(500).json({
        success: false,
        message: '腾讯云人脸识别服务配置错误',
        error: 'Missing TENCENTCLOUD_SECRET_KEY',
        timestamp: new Date().toISOString(),
        configStatus: {
          secretId: false,
          secretKey: false,
          region: true,
          endpoint: true
        },
        suggestions: [
          '请检查腾讯云SecretKey配置',
          '确认SecretKey已正确填入config/tencent.js文件',
          '检查腾讯云账户状态和API密钥权限'
        ]
      });
    }
  } catch (error) {
    console.error('健康检查失败:', error);
    res.status(500).json({
      success: false,
      message: '健康检查失败',
      error: error.message
    });
  }
});

// 获取人脸库信息路由
router.get('/face-group-info', checkTencentConfig, async (req, res) => {
  try {
    const groupParams = {
      "GroupId": FACE_LIBRARY_CONFIG.groupId
    };
    
    const groupResult = await client.GetGroupInfo(groupParams);
    const personListResult = await client.GetPersonList(groupParams);
    
    res.json({
      success: true,
      message: '获取人脸库信息成功',
      data: {
        group: groupResult,
        persons: personListResult,
        summary: {
          groupId: FACE_LIBRARY_CONFIG.groupId,
          groupName: FACE_LIBRARY_CONFIG.groupName,
          personCount: personListResult.PersonNum || 0,
          faceCount: personListResult.FaceNum || 0
        }
      }
    });
  } catch (error) {
    console.error('获取人脸库信息失败:', error);
    res.status(500).json({
      success: false,
      message: '获取人脸库信息失败',
      error: error.message,
      code: error.code || 'UNKNOWN_ERROR'
    });
  }
});

// 创建默认人脸库路由
router.post('/create-face-group', checkTencentConfig, async (req, res) => {
  try {
    console.log('开始创建默认人脸库...');
    
    const params = {
      "GroupId": "default_group",
      "GroupName": "校园帮用户人脸库",
      "GroupExDescriptions": ["校园帮应用用户人脸识别库"]
    };

    console.log('创建人脸库参数:', params);
    // 使用正确的方法名
    const result = await client.CreateGroup(params);
    console.log('人脸库创建结果:', JSON.stringify(result, null, 2));
    
    res.json({
      success: true,
      message: '默认人脸库创建成功',
      data: result,
      nextSteps: [
        '人脸库已创建，现在可以测试人脸检测功能',
        '建议先使用"人脸检测"功能',
        '然后测试"人脸注册"功能'
      ]
    });

  } catch (error) {
    console.error('创建默认人脸库失败:', error);
    
    // 如果人脸库已存在，返回成功
    if (error.code === 'ResourceInUse' || error.code === 'InvalidParameterValue.GroupNameAlreadyExist') {
      res.json({
        success: true,
        message: '默认人脸库已存在',
        data: { GroupId: "default_group" },
        nextSteps: [
          '人脸库已存在，现在可以测试人脸检测功能',
          '建议先使用"人脸检测"功能'
        ]
      });
    } else {
      res.status(500).json({
        success: false,
        message: '创建默认人脸库失败',
        error: error.message,
        code: error.code || 'UNKNOWN_ERROR',
        suggestions: [
          '检查腾讯云账户状态',
          '确认API密钥权限',
          '检查账户余额'
        ]
      });
    }
  }
});

module.exports = router;
